ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಡೇಟಾ ಪ್ರಕಾರಗಳು, ಇಂಡೆಕ್ಸಿಂಗ್, ಮತ್ತು ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ.
ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್ ಆಪ್ಟಿಮೈಸೇಶನ್: ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಟ್ಯೂನಿಂಗ್
ಪಂಡಾಸ್ ಡೇಟಾ ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್ ಮತ್ತು ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಒಂದು ಪ್ರಬಲ ಪೈಥಾನ್ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳು ಗಮನಾರ್ಹ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ನಿಧಾನಗತಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಪ್ರದರ್ಶಿಸಬಹುದು. ಈ ಲೇಖನವು ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಎರಡಕ್ಕೂ ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದರಿಂದ ನೀವು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.
ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳಲ್ಲಿ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ತಿಳಿಯುವ ಮೊದಲು, ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಡೇಟಾಫ್ರೇಮ್‌ನ ಪ್ರತಿಯೊಂದು ಕಾಲಮ್ ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇದು ಅದರ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬೇಕಾದ ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಹೀಗಿವೆ:
- int64: 64-ಬಿಟ್ ಪೂರ್ಣಾಂಕಗಳು (ಪೂರ್ಣಾಂಕಗಳಿಗೆ ಡೀಫಾಲ್ಟ್)
- float64: 64-ಬಿಟ್ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳು (ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳಿಗೆ ಡೀಫಾಲ್ಟ್)
- object: ಪೈಥಾನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು (ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಮತ್ತು ಮಿಶ್ರ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ)
- category: ಕ್ಯಾಟಗರಿಕಲ್ ಡೇಟಾ (ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳಿಗೆ ಸಮರ್ಥ)
- bool: ಬೂಲಿಯನ್ ಮೌಲ್ಯಗಳು (True/False)
- datetime64: ದಿನಾಂಕ-ಸಮಯದ ಮೌಲ್ಯಗಳು
object ಡೇಟಾ ಪ್ರಕಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಅತಿ ಹೆಚ್ಚು ಮೆಮೊರಿ ಬಳಸುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಪೈಥಾನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಿಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಇದು ಇಂಟಿಜರ್ ಅಥವಾ ಫ್ಲೋಟ್‌ಗಳಂತಹ ಪ್ರಾಥಮಿಕ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗಿಂತ ಗಮನಾರ್ಹವಾಗಿ ದೊಡ್ಡದಾಗಿರಬಹುದು. ಸಣ್ಣ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸಹ `object` ಆಗಿ ಸಂಗ್ರಹಿಸಿದಾಗ, ಅಗತ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚು ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತವೆ. ಅಂತೆಯೇ, `int32` ಸಾಕಾಗುವ ಕಡೆ `int64` ಅನ್ನು ಬಳಸುವುದು ಮೆಮೊರಿಯನ್ನು ವ್ಯರ್ಥ ಮಾಡುತ್ತದೆ.
ಉದಾಹರಣೆ: ಡೇಟಾಫ್ರೇಮ್ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು
ಡೇಟಾಫ್ರೇಮ್‌ನ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು memory_usage() ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು:
import pandas as pd
import numpy as np
data = {
'col1': np.random.randint(0, 1000, 100000),
'col2': np.random.rand(100000),
'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
'col4': ['This is a long string'] * 100000
}
df = pd.DataFrame(data)
memory_usage = df.memory_usage(deep=True)
print(memory_usage)
print(df.dtypes)
deep=True ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ (ಸ್ಟ್ರಿಂಗ್‌ಗಳಂತಹ) ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. `deep=True` ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಕೇವಲ ಪಾಯಿಂಟರ್‌ಗಳ ಮೆಮೊರಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ, ಆಧಾರವಾಗಿರುವ ಡೇಟಾವನ್ನಲ್ಲ.
ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು
ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದು ನಿಮ್ಮ ಡೇಟಾಫ್ರೇಮ್ ಕಾಲಮ್‌ಗಳಿಗೆ ಅತ್ಯಂತ ಸೂಕ್ತವಾದ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು. ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ತಂತ್ರಗಳಿವೆ:
1. ಸಂಖ್ಯಾತ್ಮಕ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಡೌನ್‌ಕಾಸ್ಟ್ ಮಾಡುವುದು
ನಿಮ್ಮ ಇಂಟಿಜರ್ ಅಥವಾ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಕಾಲಮ್‌ಗಳಿಗೆ 64-ಬಿಟ್ ನಿಖರತೆಯ ಪೂರ್ಣ ಶ್ರೇಣಿಯ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ನೀವು ಅವುಗಳನ್ನು int32, int16, float32, ಅಥವಾ float16 ನಂತಹ ಸಣ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಡೌನ್‌ಕಾಸ್ಟ್ ಮಾಡಬಹುದು. ಇದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ವಿಶೇಷವಾಗಿ ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು.
ಉದಾಹರಣೆ: ವಯಸ್ಸನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕಾಲಮ್ ಅನ್ನು ಪರಿಗಣಿಸಿ, ಅದು 120 ಕ್ಕಿಂತ ಹೆಚ್ಚಾಗುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ. ಇದನ್ನು `int64` ಆಗಿ ಸಂಗ್ರಹಿಸುವುದು ವ್ಯರ್ಥ; `int8` (ವ್ಯಾಪ್ತಿ -128 ರಿಂದ 127) ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿರುತ್ತದೆ.
def downcast_numeric(df):
"""Downcasts numeric columns to the smallest possible data type."""
for col in df.columns:
if pd.api.types.is_integer_dtype(df[col]):
df[col] = pd.to_numeric(df[col], downcast='integer')
elif pd.api.types.is_float_dtype(df[col]):
df[col] = pd.to_numeric(df[col], downcast='float')
return df
df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)
pd.to_numeric() ಫಂಕ್ಷನ್, downcast ಆರ್ಗ್ಯುಮೆಂಟ್‌ನೊಂದಿಗೆ, ಕಾಲಮ್‌ನಲ್ಲಿನ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಬಲ್ಲ ಚಿಕ್ಕ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. `copy()` ಮೂಲ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಮಾಹಿತಿ ನಷ್ಟವಾಗದಂತೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಡೌನ್‌ಕಾಸ್ಟ್ ಮಾಡುವ ಮೊದಲು ಯಾವಾಗಲೂ ನಿಮ್ಮ ಡೇಟಾದಲ್ಲಿನ ಮೌಲ್ಯಗಳ ವ್ಯಾಪ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ.
2. ಕ್ಯಾಟಗರಿಕಲ್ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸುವುದು
ಒಂದು ಕಾಲಮ್ ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಅನನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು ಅದನ್ನು category ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು. ಕ್ಯಾಟಗರಿಕಲ್ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಪ್ರತಿಯೊಂದು ಅನನ್ಯ ಮೌಲ್ಯವನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಸಂಗ್ರಹಿಸುತ್ತವೆ, ಮತ್ತು ನಂತರ ಕಾಲಮ್‌ನಲ್ಲಿನ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಇಂಟಿಜರ್ ಕೋಡ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಇದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಕಾಲಮ್‌ಗಳಿಗೆ.
ಉದಾಹರಣೆ: ದೇಶದ ಕೋಡ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಕಾಲಮ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ನೀವು ಸೀಮಿತ ಸಂಖ್ಯೆಯ ದೇಶಗಳೊಂದಿಗೆ (ಉದಾಹರಣೆಗೆ, ಯುರೋಪಿಯನ್ ಯೂನಿಯನ್‌ನಲ್ಲಿರುವ ದೇಶಗಳು ಮಾತ್ರ) ವ್ಯವಹರಿಸುತ್ತಿದ್ದರೆ, ಇದನ್ನು ಕ್ಯಾಟಗರಿಯಾಗಿ ಸಂಗ್ರಹಿಸುವುದು ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಸಂಗ್ರಹಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ.
def optimize_categories(df):
"""Converts object columns with low cardinality to categorical type."""
for col in df.columns:
if df[col].dtype == 'object':
num_unique_values = len(df[col].unique())
num_total_values = len(df[col])
if num_unique_values / num_total_values < 0.5:
df[col] = df[col].astype('category')
return df
df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)
ಈ ಕೋಡ್, ಒಂದು ಆಬ್ಜೆಕ್ಟ್ ಕಾಲಮ್‌ನಲ್ಲಿನ ಅನನ್ಯ ಮೌಲ್ಯಗಳ ಸಂಖ್ಯೆಯು ಒಟ್ಟು ಮೌಲ್ಯಗಳ 50% ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದಲ್ಲಿ, ಅದು ಕಾಲಮ್ ಅನ್ನು ಕ್ಯಾಟಗರಿಕಲ್ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ. 50% ಮಿತಿ ಒಂದು ಅಂದಾಜು ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾದ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಆಧರಿಸಿ ಸರಿಹೊಂದಿಸಬಹುದು. ಈ ವಿಧಾನವು ಕಾಲಮ್‌ನಲ್ಲಿ ಅನೇಕ ಪುನರಾವರ್ತಿತ ಮೌಲ್ಯಗಳಿದ್ದಾಗ ಹೆಚ್ಚು ಪ್ರಯೋಜನಕಾರಿಯಾಗಿದೆ.
3. ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗಾಗಿ ಆಬ್ಜೆಕ್ಟ್ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ತಪ್ಪಿಸುವುದು
ಹಿಂದೆ ಹೇಳಿದಂತೆ, object ಡೇಟಾ ಪ್ರಕಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಅತಿ ಹೆಚ್ಚು ಮೆಮೊರಿ ಬಳಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಿದಾಗ. ಸಾಧ್ಯವಾದರೆ, ಸ್ಟ್ರಿಂಗ್ ಕಾಲಮ್‌ಗಳಿಗಾಗಿ object ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಪ್ರಯತ್ನಿಸಿ. ಕಡಿಮೆ ಕಾರ್ಡಿನಾಲಿಟಿ ಇರುವ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಕ್ಯಾಟಗರಿಕಲ್ ಪ್ರಕಾರಗಳು ಉತ್ತಮ. ಕಾರ್ಡಿನಾಲಿಟಿ ಹೆಚ್ಚಾಗಿದ್ದರೆ, ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸಂಖ್ಯಾತ್ಮಕ ಕೋಡ್‌ಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಬಹುದೇ ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ಡೇಟಾವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪಿಸಬಹುದೇ ಎಂದು ಪರಿಗಣಿಸಿ.
ನೀವು ಕಾಲಮ್‌ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಬೇಕಾದರೆ, ನೀವು ಅದನ್ನು ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರವಾಗಿ ಇರಿಸಬೇಕಾಗಬಹುದು, ಆದರೆ ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮೊದಲೇ ಮಾಡಿ, ನಂತರ ಹೆಚ್ಚು ಸಮರ್ಥ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದೇ ಎಂದು ಪರಿಗಣಿಸಿ.
4. ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಡೇಟಾ
ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಮಾಹಿತಿಗಾಗಿ `datetime64` ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಿ. ರೆಸಲ್ಯೂಶನ್ ಸೂಕ್ತವಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ (ನ್ಯಾನೊಸೆಕೆಂಡ್ ರೆಸಲ್ಯೂಶನ್ ಅನಗತ್ಯವಾಗಿರಬಹುದು). ಪಂಡಾಸ್ ಟೈಮ್ ಸೀರೀಸ್ ಡೇಟಾವನ್ನು ಅತ್ಯಂತ ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ.
ಡೇಟಾಫ್ರೇಮ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು
ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದರ ಜೊತೆಗೆ, ನೀವು ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳ ಮೇಲೆ ಮಾಡುವ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವ ಮೂಲಕ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ತಂತ್ರಗಳಿವೆ:
1. ವೆಕ್ಟರೈಸೇಶನ್
ವೆಕ್ಟರೈಸೇಶನ್ ಎನ್ನುವುದು ಪ್ರತ್ಯೇಕ ಅಂಶಗಳ ಮೇಲೆ ಇಟರೇಟ್ ಮಾಡುವ ಬದಲು, ಸಂಪೂರ್ಣ ಅರೇಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳ ಮೇಲೆ ಒಂದೇ ಬಾರಿಗೆ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ. ಪಂಡಾಸ್ ವೆಕ್ಟರೈಸ್ಡ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಜ್ ಆಗಿದೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಬಳಸುವುದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ಎಕ್ಸ್‌ಪ್ಲಿಸಿಟ್ ಲೂಪ್‌ಗಳನ್ನು ತಪ್ಪಿಸಿ. ಪಂಡಾಸ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ಫಂಕ್ಷನ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸಮಾನವಾದ ಪೈಥಾನ್ ಲೂಪ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚು ವೇಗವಾಗಿರುತ್ತವೆ.
ಉದಾಹರಣೆ: ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯದ ವರ್ಗವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಕಾಲಮ್ ಮೂಲಕ ಇಟರೇಟ್ ಮಾಡುವ ಬದಲು, pow() ಫಂಕ್ಷನ್ ಬಳಸಿ:
# Inefficient (using a loop)
import time
start_time = time.time()
results = []
for value in df['col2']:
results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Loop time: {end_time - start_time:.4f} seconds")
# Efficient (using vectorization)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Vectorized time: {end_time - start_time:.4f} seconds")
ವೆಕ್ಟರೈಸ್ಡ್ ವಿಧಾನವು ಸಾಮಾನ್ಯವಾಗಿ ಲೂಪ್-ಆಧಾರಿತ ವಿಧಾನಕ್ಕಿಂತ ಹಲವು ಪಟ್ಟು ವೇಗವಾಗಿರುತ್ತದೆ.
2. apply() ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸುವುದು
apply() ವಿಧಾನವು ಡೇಟಾಫ್ರೇಮ್‌ನ ಪ್ರತಿಯೊಂದು ಸಾಲು ಅಥವಾ ಕಾಲಮ್‌ಗೆ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಅನ್ವಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ವೆಕ್ಟರೈಸ್ಡ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಿಂತ ನಿಧಾನವಾಗಿರುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕೂ ಪೈಥಾನ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಯುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ವೆಕ್ಟರೈಸ್ಡ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಸಾಧ್ಯವಾಗದಿದ್ದಾಗ ಮಾತ್ರ apply() ಬಳಸಿ.
ನೀವು `apply()` ಅನ್ನು ಬಳಸಬೇಕಾದರೆ, ನೀವು ಅನ್ವಯಿಸುತ್ತಿರುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ವೆಕ್ಟರೈಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ. ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆ ಸುಧಾರಣೆಗಳಿಗಾಗಿ ಫಂಕ್ಷನ್ ಅನ್ನು ಮಷಿನ್ ಕೋಡ್‌ಗೆ ಕಂಪೈಲ್ ಮಾಡಲು ನಂಬಾದ `jit` ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
from numba import jit
@jit(nopython=True)
def my_function(x):
return x * 2 # Example function
df['col2_applied'] = df['col2'].apply(my_function)
3. ಕಾಲಮ್‌ಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ಆಯ್ಕೆ ಮಾಡುವುದು
ಡೇಟಾಫ್ರೇಮ್‌ನಿಂದ ಕಾಲಮ್‌ಗಳ ಉಪವಿಭಾಗವನ್ನು ಆಯ್ಕೆಮಾಡುವಾಗ, ಉತ್ತಮ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಈ ಕೆಳಗಿನ ವಿಧಾನಗಳನ್ನು ಬಳಸಿ:
- ನೇರ ಕಾಲಮ್ ಆಯ್ಕೆ:
df[['col1', 'col2']](ಕೆಲವು ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ವೇಗವಾದದ್ದು) - ಬೂಲಿಯನ್ ಇಂಡೆಕ್ಸಿಂಗ್:
df.loc[:, [True if col.startswith('col') else False for col in df.columns]](ಒಂದು ಷರತ್ತಿನ ಆಧಾರದ ಮೇಲೆ ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಉಪಯುಕ್ತ)
ಕಾಲಮ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳೊಂದಿಗೆ df.filter() ಅನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ, ಏಕೆಂದರೆ ಇದು ಇತರ ವಿಧಾನಗಳಿಗಿಂತ ನಿಧಾನವಾಗಿರಬಹುದು.
4. ಜಾಯಿನ್ ಮತ್ತು ಮರ್ಜ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು
ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಜಾಯಿನ್ ಮತ್ತು ಮರ್ಜ್ ಮಾಡುವುದು ಗಣನೀಯವಾಗಿ ದುಬಾರಿಯಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ. ಜಾಯಿನ್ ಮತ್ತು ಮರ್ಜ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಕೆಲವು ಸಲಹೆಗಳು ಇಲ್ಲಿವೆ:
- ಸೂಕ್ತ ಜಾಯಿನ್ ಕೀಗಳನ್ನು ಬಳಸಿ: ಜಾಯಿನ್ ಕೀಗಳು ಒಂದೇ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಇಂಡೆಕ್ಸ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
- ಜಾಯಿನ್ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ: ನಿಮ್ಮ ಅವಶ್ಯಕತೆಗಳಿಗೆ ಅನುಗುಣವಾಗಿ ಸೂಕ್ತವಾದ ಜಾಯಿನ್ ಪ್ರಕಾರವನ್ನು (ಉದಾ.,
inner,left,right,outer) ಬಳಸಿ. ಇನ್ನರ್ ಜಾಯಿನ್ ಸಾಮಾನ್ಯವಾಗಿ ಔಟರ್ ಜಾಯಿನ್‌ಗಿಂತ ವೇಗವಾಗಿರುತ್ತದೆ. join()ಬದಲಿಗೆmerge()ಬಳಸಿ:merge()ಫಂಕ್ಷನ್ ಹೆಚ್ಚು ಬಹುಮುಖವಾಗಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿjoin()ವಿಧಾನಕ್ಕಿಂತ ವೇಗವಾಗಿರುತ್ತದೆ.
ಉದಾಹರಣೆ:
df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})
# Efficient inner join
df_merged = pd.merge(df1, df2, on='key', how='inner')
print(df_merged)
5. ಅನಗತ್ಯವಾಗಿ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಕಾಪಿ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸುವುದು
ಅನೇಕ ಪಂಡಾಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಡೇಟಾಫ್ರೇಮ್‌ಗಳ ಪ್ರತಿಗಳನ್ನು ರಚಿಸುತ್ತವೆ, ಇದು ಮೆಮೊರಿ-ತೀವ್ರ ಮತ್ತು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವಂತಹದ್ದಾಗಿರಬಹುದು. ಅನಗತ್ಯ ನಕಲು ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಲು, ಲಭ್ಯವಿರುವಾಗ inplace=True ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಬಳಸಿ, ಅಥವಾ ಒಂದು ಕಾರ್ಯಾಚರಣೆಯ ಫಲಿತಾಂಶವನ್ನು ಮೂಲ ಡೇಟಾಫ್ರೇಮ್‌ಗೆ ಮರು-ನಿಯೋಜಿಸಿ. `inplace=True` ಜೊತೆಗೆ ಬಹಳ ಎಚ್ಚರಿಕೆಯಿಂದಿರಿ ಏಕೆಂದರೆ ಅದು ದೋಷಗಳನ್ನು ಮರೆಮಾಚಬಹುದು ಮತ್ತು ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ಕಷ್ಟಕರವಾಗಿಸಬಹುದು. ಸ್ವಲ್ಪ ಕಡಿಮೆ ಕಾರ್ಯಕ್ಷಮತೆ ಹೊಂದಿದ್ದರೂ ಮರು-ನಿಯೋಜಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಸುರಕ್ಷಿತವಾಗಿದೆ.
ಉದಾಹರಣೆ:
# Inefficient (creates a copy)
df_filtered = df[df['col1'] > 500]
# Efficient (modifies the original DataFrame in place - CAUTION)
df.drop(df[df['col1'] <= 500].index, inplace=True)
#SAFER - reassigns, avoids inplace
df = df[df['col1'] > 500]
6. ಚಂಕಿಂಗ್ ಮತ್ತು ಇಟರೇಟಿಂಗ್
ಮೆಮೊರಿಯಲ್ಲಿ ಹಿಡಿಸಲಾಗದ ಅತ್ಯಂತ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗಾಗಿ, ಡೇಟಾವನ್ನು ಚಂಕ್‌ಗಳಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಫೈಲ್‌ಗಳಿಂದ ಡೇಟಾವನ್ನು ಓದುವಾಗ `chunksize` ಪ್ಯಾರಾಮೀಟರ್ ಬಳಸಿ. ಚಂಕ್‌ಗಳ ಮೂಲಕ ಇಟರೇಟ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿಯೊಂದು ಚಂಕ್‌ನ ಮೇಲೆ ನಿಮ್ಮ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನಿರ್ವಹಿಸಿ. ವಿಶ್ಲೇಷಣೆ ಸರಿಯಾಗಿ ಉಳಿದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆಯನ್ನು ಬಯಸುತ್ತದೆ, ಏಕೆಂದರೆ ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕಾಗುತ್ತದೆ.
# Read CSV in chunks
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
# Process each chunk
print(chunk.shape)
7. ಸಮಾನಾಂತರ ಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ ಡಾಸ್ಕ್ ಬಳಸುವುದು
ಡಾಸ್ಕ್ ಒಂದು ಸಮಾನಾಂತರ ಕಂಪ್ಯೂಟಿಂಗ್ ಲೈಬ್ರರಿಯಾಗಿದ್ದು ಅದು ಪಂಡಾಸ್‌ನೊಂದಿಗೆ ಮನಬಂದಂತೆ ಸಂಯೋಜನೆಗೊಳ್ಳುತ್ತದೆ. ಇದು ನಿಮಗೆ ದೊಡ್ಡ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ. ಡಾಸ್ಕ್ ಡೇಟಾಫ್ರೇಮ್ ಅನ್ನು ಸಣ್ಣ ವಿಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಅನೇಕ ಕೋರ್‌ಗಳು ಅಥವಾ ಮಷಿನ್‌ಗಳಲ್ಲಿ ವಿತರಿಸುತ್ತದೆ.
import dask.dataframe as dd
# Create a Dask DataFrame
ddf = dd.read_csv('large_data.csv')
# Perform operations on the Dask DataFrame
ddf_filtered = ddf[ddf['col1'] > 500]
# Compute the result (this triggers the parallel computation)
result = ddf_filtered.compute()
print(result.head())
ವೇಗದ ಲುಕಪ್‌ಗಳಿಗಾಗಿ ಇಂಡೆಕ್ಸಿಂಗ್
ಒಂದು ಕಾಲಮ್‌ನಲ್ಲಿ ಇಂಡೆಕ್ಸ್ ರಚಿಸುವುದರಿಂದ ಲುಕಪ್ ಮತ್ತು ಫಿಲ್ಟರಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವೇಗಗೊಳಿಸಬಹುದು. ಪಂಡಾಸ್ ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ ಸಾಲುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚಲು ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
# Set 'col3' as the index
df = df.set_index('col3')
# Faster lookup
value = df.loc['A']
print(value)
# Reset the index
df = df.reset_index()
ಆದಾಗ್ಯೂ, ಹಲವಾರು ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ರಚಿಸುವುದರಿಂದ ಮೆಮೊರಿ ಬಳಕೆ ಹೆಚ್ಚಾಗಬಹುದು ಮತ್ತು ರೈಟ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಧಾನಗೊಳಿಸಬಹುದು. ಆಗಾಗ್ಗೆ ಲುಕಪ್ ಅಥವಾ ಫಿಲ್ಟರಿಂಗ್‌ಗೆ ಬಳಸಲಾಗುವ ಕಾಲಮ್‌ಗಳ ಮೇಲೆ ಮಾತ್ರ ಇಂಡೆಕ್ಸ್‌ಗಳನ್ನು ರಚಿಸಿ.
ಇತರ ಪರಿಗಣನೆಗಳು
- ಹಾರ್ಡ್‌ವೇರ್: ನೀವು ನಿರಂತರವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ ನಿಮ್ಮ ಹಾರ್ಡ್‌ವೇರ್ (ಸಿಪಿಯು, ರಾಮ್, ಎಸ್‌ಎಸ್‌ಡಿ) ಅನ್ನು ಅಪ್‌ಗ್ರೇಡ್ ಮಾಡುವುದನ್ನು ಪರಿಗಣಿಸಿ.
- ಸಾಫ್ಟ್‌ವೇರ್: ನೀವು ಪಂಡಾಸ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಬಳಸುತ್ತಿರುವಿರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ, ಏಕೆಂದರೆ ಹೊಸ ಆವೃತ್ತಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸುಧಾರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ.
- ಪ್ರೊಫೈಲಿಂಗ್: ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಪ್ರೊಫೈಲಿಂಗ್ ಪರಿಕರಗಳನ್ನು (ಉದಾ.,
cProfile,line_profiler) ಬಳಸಿ. - ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಫಾರ್ಮ್ಯಾಟ್: ಸಿಎಸ್‌ವಿ ಬದಲು ಪಾರ್ಕೆಟ್ ಅಥವಾ ಫೆದರ್‌ನಂತಹ ಹೆಚ್ಚು ಸಮರ್ಥ ಡೇಟಾ ಸಂಗ್ರಹಣೆ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು ಕಾಲಮ್ನಾರ್ ಆಗಿರುತ್ತವೆ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕುಚಿತಗೊಂಡಿರುತ್ತವೆ, ಇದು ಸಣ್ಣ ಫೈಲ್ ಗಾತ್ರಗಳಿಗೆ ಮತ್ತು ವೇಗದ ಓದುವ/ಬರೆಯುವ ಸಮಯಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ತೀರ್ಮಾನ
ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಸಮರ್ಥವಾಗಿ ಕೆಲಸ ಮಾಡಲು ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಪಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು ಬಹಳ ಮುಖ್ಯ. ಸೂಕ್ತವಾದ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಆರಿಸುವ ಮೂಲಕ, ವೆಕ್ಟರೈಸ್ಡ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಇಂಡೆಕ್ಸ್ ಮಾಡುವ ಮೂಲಕ, ನೀವು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು. ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಲು ಮರೆಯದಿರಿ ಮತ್ತು ಅತ್ಯಂತ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗಾಗಿ ಚಂಕಿಂಗ್ ಅಥವಾ ಡಾಸ್ಕ್ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಈ ತಂತ್ರಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ, ನೀವು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಮ್ಯಾನಿಪ್ಯುಲೇಶನ್‌ಗಾಗಿ ಪಂಡಾಸ್‌ನ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಬಹುದು.